import 'package:flutter/material.dart';
import 'package:petitparser/petitparser.dart';

import 'custom_dialog.dart';

///解析各种格式的数据，包括XML、JSON、HTTML、CSS
///可以使用 map 方法来对解析结果进行转换，或者使用 token 方法来获取解析结果的详细信息（如文本、行号、列号等）。
class EParserAction extends StatefulWidget {
  const EParserAction({super.key});

  @override
  State<EParserAction> createState() => _EParserActionState();
}

class _EParserActionState extends State<EParserAction> {
  var resultStr = '';
  final invalidStr = 'Invalid input';
  @override
  Widget build(BuildContext context) {
    return Scaffold(
        appBar: AppBar(
          title: const Text('解析动作'),
        ),
        body: SingleChildScrollView(
          child: Container(
            padding: EdgeInsets.all(16),
            child: Center(
              child: Column(
                children: [
                  Row(
                    mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                    children: [
                      _buttonWidget(() {
                        _jsonParser();
                      }, '解析JSON数据'),
                      _buttonWidget(() {
                        _xmlParser();
                      }, '解析XML数据'),
                    ],
                  ),
                  Row(
                    mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                    children: [
                      _buttonWidget(() {
                        _htmlParser();
                      }, '解析HTML数据'),
                      _buttonWidget(() {
                        _cssParser();
                      }, '解析CSS数据'),
                    ],
                  ),
                ],
              ),
            ),
          ),
        ));
  }

  Widget _buttonWidget(VoidCallback onTap, String title) {
    return TextButton(
        onPressed: onTap,
        child: Container(
          padding: EdgeInsets.all(20),
          child: Text(title),
        ));
  }

  void _jsonParser() {
    // 创建一个 JSON 解析器
    final parser = char('{')
        .seq(letter().plus().flatten().trim())
        .seq(char(':'))
        .seq(any().star().flatten().trim())
        .seq(char('}'))
        .map((value) {
      // 将解析结果转换为 Map
      return {value[1]: value[3]};
    });

    // 定义一个简单的 JSON 字符串
    final jsonString = '{"name": "John"}';

    // 使用解析器来解析 JSON 字符串
    final result = parser.parse(jsonString);
    if (result.isSuccess) {
      // 解析成功
      CustomDialog('{"name": "John"}', result.value.toString());
      print('Parsed JSON: ${result.value}');
    } else {
      // 解析失败
      CustomDialogFailed(
        title: '解析失败',
        message: result.message,
      );
      print('Parse failed: ${result.message}');
    }
  }

  void _xmlParser() {
    // 创建一个 XML 解析器
    final parser = char('<')
        .seq(letter().plus().flatten())
        .seq(char('>'))
        .seq(any().starLazy(char('<')).flatten())
        .seq(char('<').seq(char('/')).seq(letter().plus().flatten()).seq(char('>')))
        .map((value) {
      // 将解析结果转换为 Map
      return {value[1]: value[3]};
    });

    // 定义一个简单的 XML 字符串
    final xmlString = '<name>John</name>';

    // 使用解析器来解析 XML 字符串
    final result = parser.parse(xmlString);
    if (result.isSuccess) {
      // 解析成功
      CustomDialog('<name>John</name>', result.value.toString());
      print('Parsed XML: ${result.value}');
    } else {
      // 解析失败
      CustomDialogFailed(
        title: '解析失败',
        message: result.message,
      );
      print('Parse failed: ${result.message}');
    }
  }

  void _htmlParser() {
    // 创建一个 HTML 解析器
    final parser = char('<')
        .seq(letter().plus().flatten())
        .seq(char('>'))
        .seq(any().starLazy(char('<')).flatten())
        .seq(char('<').seq(char('/')).seq(letter().plus().flatten()).seq(char('>')))
        .map((value) {
      // 将解析结果转换为 Map
      return {value[1]: value[3]};
    });

    // 定义一个简单的 HTML 字符串
    final htmlString = '<h1>Hello, World!</h1>';

    // 使用解析器来解析 HTML 字符串
    final result = parser.parse(htmlString);
    if (result.isSuccess) {
      // 解析成功
      CustomDialog('<h1>Hello, World!</h1>', result.value.toString());
      print('Parsed HTML: ${result.value}');
    } else {
      // 解析失败
      CustomDialogFailed(
        title: '解析失败',
        message: result.message,
      );
      print('Parse failed: ${result.message}');
    }
  }

  void _cssParser() {
    // 创建一个 CSS 解析器
    final parser = letter()
        .plus()
        .flatten()
        .trim() // 解析选择器
        .seq(char('{')) // 解析 '{' 符号
        .seq(letter().plus().flatten().trim()) // 解析属性名
        .seq(char(':')) // 解析 ':' 符号
        .seq(any().starLazy(char('}')).flatten().trim()) // 解析属性值
        .seq(char('}')) // 解析 '}' 符号
        .map((value) {
      // 将解析结果转换为 Map
      return {
        value[0]: {value[2]: value[4]}
      };
    });

    // 定义一个简单的 CSS 字符串
    final cssString = 'h1 { color: blue; }';

    // 使用解析器来解析 CSS 字符串
    final result = parser.parse(cssString);
    if (result.isSuccess) {
      // 解析成
      CustomDialog('h1 { color: blue; }', result.value.toString());
      print('Parsed CSS: ${result.value}');
    } else {
      // 解析失败
      CustomDialogFailed(
        title: '解析失败',
        message: result.message,
      );
      print('Parse failed: ${result.message}');
    }
  }
}

void _lookahead() {
  // 创建一个解析器，它期望看到一个 'a'，后面不是 'c'
  final parser = char('a').seq(char('c').not());

  // 应该成功解析 "ac"，并返回 ['a', 'd']
  final result1 = parser.parse('ad');
  if (result1.isSuccess) {
    print('Parsed successfully: ${result1.value}');
  } else {
    print('Parse failed: ${result1.message}');
  }

  // 应该无法解析 "ac"，因为它期望在 "a" 后面看到的不是 "c"
  final result2 = parser.parse('ac');
  if (result2.isSuccess) {
    print('Parsed successfully: ${result2.value}');
  } else {
    print('Parse failed: ${result2.message}');
  }
}
